/*
 * Copyright 2011 Andrew Gottemoller.
 *
 * This software is a copyrighted work licensed under the terms of the
 * Trigger Script license.  Please consult the file "TS_LICENSE" for
 * details.
 */

#include "doc.h"


char ffilib_doc_pipe[] = "Pipes\n"
                         "pipe(file_path)\n"
                         "# Open the specified file as a pipe.  Each line of text\n"
                         "# in the file will trigger the listen_pipe() action.\n"
                         "# As data is written to the file, the listen actions\n"
                         "# will trigger.\n"
                         "# \n"
                         "# Syntax:\n"
                         "# handle = pipe(file_path)\n"
                         "# \n"
                         "# file_path: A path to a file to listen to\n"
                         "# \n"
                         "# Example:\n"
                         "pipe(\"C:\\\\foo.txt\")\n"
                         "\n"
                         "action listen_pipe()\n"
                         "    print(read_pipe(0))\n"
                         "end\n";

char ffilib_doc_read_pipe[] = "Pipes\n"
                              "read_pipe(argument_number)\n"
                              "# Read from the currently selected pipe, picking the\n"
                              "# specified argument.  Arguments are space seperated and\n"
                              "# the argument number is a 0 based index.\n"
                              "# \n"
                              "# Syntax:\n"
                              "# argument = read_pipe(argument_number)\n"
                              "# \n"
                              "# argument: The returned argument as a string\n"
                              "# \n"
                              "# argument_number: The 0 based index of the argument to read\n"
                              "# \n"
                              "# Example:\n"
                              "pipe(\"C:\\\\foo.txt\")\n"
                              "\n"
                              "action listen_pipe()\n"
                              "    print(read_pipe(0))\n"
                              "end\n";

char ffilib_doc_hread_pipe[] = "Pipes\n"
                               "hread_pipe(handle, argument_number)\n"
                               "# Read from the pipe specified by the handle, picking the\n"
                               "# specified argument.  Arguments are space seperated and\n"
                               "# the argument number is a 0 based index.\n"
                               "# \n"
                               "# Syntax:\n"
                               "# argument = hread_pipe(handle, argument_number)\n"
                               "# \n"
                               "# argument: The returned argument as a string\n"
                               "# \n"
                               "# handle: A handle to a pipe returned by pipe()\n"
                               "# \n"
                               "# argument_number: The 0 based index of the argument to read\n"
                               "# \n"
                               "# Example:\n"
                               "p = pipe(\"C:\\\\foo.txt\")\n"
                               "\n"
                               "action hlisten_pipe(p)\n"
                               "    print(hread_pipe(p, 0))\n"
                               "end\n";

char ffilib_doc_listen_pipe[] = "Pipes\n"
                                "listen_pipe()\n"
                                "# Listen to the current pipe, waiting for a line of text to be\n"
                                "# written to the pipe.  Once the action is triggered, the\n"
                                "# next line of text won't be read again until the action\n"
                                "# completes\n"
                                "# \n"
                                "# Syntax:\n"
                                "# listen_pipe()\n"
                                "# \n"
                                "# Example:\n"
                                "pipe(\"C:\\\\foo.txt\")\n"
                                "\n"
                                "action listen_pipe()\n"
                                "    print(read_pipe(0))\n"
                                "end\n";

char ffilib_doc_hlisten_pipe[] = "Pipes\n"
                                 "hlisten_pipe(handle)\n"
                                 "# Listen to the specified pipe, waiting for a line of text to be\n"
                                 "# written to the pipe.  Once the action is triggered, the\n"
                                 "# next line of text won't be read again until the action\n"
                                 "# completes\n"
                                 "# \n"
                                 "# Syntax:\n"
                                 "# hlisten_pipe(handle)\n"
                                 "# \n"
                                 "# handle: A handle to a pipe returned by pipe()\n"
                                 "# \n"
                                 "# Example:\n"
                                 "p = pipe(\"C:\\\\foo.txt\")\n"
                                 "\n"
                                 "action hlisten_pipe(p)\n"
                                 "    print(hread_pipe(p, 0))\n"
                                 "end\n";

char ffilib_doc_print[] = "Messages\n"
                          "print(message_text)\n"
                          "# Prints the specified message text to the display\n"
                          "# for the user running the script to see.  This\n"
                          "# function does not perform any other interaction\n"
                          "# with the user.\n"
                          "# \n"
                          "# Syntax:\n"
                          "#   print(text)\n"
                          "# \n"
                          "# text: Any string you wish to display\n"
                          "# \n"
                          "# Example:\n"
                          "for i = 10 downto 0\n"
                          "    print(i+\" hours until the world ends\")\n"
                          "end\n";

char ffilib_doc_message[] = "Messages\n"
                            "message(message_text)\n"
                            "# Displays the specified message text the user\n"
                            "# running the script.  This function will block\n"
                            "# until the user acknowledges the message.\n"
                            "# \n"
                            "# Syntax:\n"
                            "#   message(text)\n"
                            "# \n"
                            "# text: Any string you wish to display to the user\n"
                            "# \n"
                            "# Example:\n"
                            "for i = 10 downto 0\n"
                            "    message(i+\" hours until the world ends, press OK to continue\")\n"
                            "end\n";

char ffilib_doc_choice[] = "Messages\n"
                           "choice(message_text)\n"
                           "# Displays the specified message text the user\n"
                           "#  running the script.  The user is then prompted\n"
                           "# for an answer, either 'Yes' or 'No'.  If the user\n"
                           "# chooses 'Yes', a value of true is returned.\n"
                           "#  Otherwise, false is returned.\n"
                           "# \n"
                           "# Syntax:\n"
                           "#   boolean = choice(text)\n"
                           "# \n"
                           "# text: Any string you wish to display to the user\n"
                           "# \n"
                           "# Example:\n"
                           "for i = 10 downto 0\n"
                           "    continue_it = choice(\"Do you want to waste your time?\")\n"
                           "    if continue_it == false\n"
                           "        break\n"
                           "    end\n"
                           "end\n";

char ffilib_doc_uniform_random[] = "Math (Statistics)\n"
                                   "uniform_random()\n"
                                   "# Generates a uniform random variable in the range\n"
                                   "# of 0.0 and 1.0.  The result is a real number.\n"
                                   "# \n"
                                   "# Syntax:\n"
                                   "#   real = uniform_random()\n"
                                   "# \n"
                                   "# Example:\n"
                                   "my_random = uniform_random()\n";

char ffilib_doc_gaussian_random[] = "Math (Statistics)\n"
                                    "gaussian_random(mean, standard_deviation)\n"
                                    "# Generates a random number with a Gaussian\n"
                                    "# distribution using the specified mean and\n"
                                    "# standard deviation and returns the result as\n"
                                    "# a real number.\n"
                                    "# \n"
                                    "# Syntax:\n"
                                    "#   real = gaussian_random(mean, standard_deviation)\n"
                                    "# \n"
                                    "# mean: Any real number representing the mean of the\n"
                                    "#   distribution\n"
                                    "# \n"
                                    "# standard_deviation: Any real number representing the\n"
                                    "#   standard deviation of the distribution\n"
                                    "# \n"
                                    "# Example:\n"
                                    "random_number = gaussian_random(10.0, 0.05)\n";

char ffilib_doc_min[] = "Math (Basic)\n"
                        "min(value1, value2)\n"
                        "# Returns the minimum of the two values specified.  The\n"
                        "# return type is the same as the type of value1 and\n"
                        "# value 2.\n"
                        "# \n"
                        "# Syntax:\n"
                        "#   min_value = min(value1, value2)\n"
                        "# \n"
                        "# value1: The first value, of type boolean, integer, or\n"
                        "#   real\n"
                        "# \n"
                        "# value2: The second value, of type boolean, integer, or\n"
                        "#   real\n"
                        "# \n"
                        "# Example:\n"
                        "min_val = min(10.0, 5)\n";

char ffilib_doc_max[] = "Math (Basic)\n"
                        "max(value1, value2)\n"
                        "# Returns the maximum of the two values specified.  The\n"
                        "# return type is the same as the type of value1 and\n"
                        "# value 2.\n"
                        "# \n"
                        "# Syntax:\n"
                        "#   max_value = max(value1, value2)\n"
                        "# \n"
                        "# value1: The first value, of type boolean, integer, or\n"
                        "#   real\n"
                        "# \n"
                        "# value2: The second value, of type boolean, integer, or\n"
                        "#   real\n"
                        "# \n"
                        "# Example:\n"
                        "max_val = max(10.0, 5)\n";

char ffilib_doc_ceil[] = "Math (Basic)\n"
                         "ceil(value)\n"
                         "# Returns the smallest integer not less than the value\n"
                         "# specified.\n"
                         "# \n"
                         "# Syntax:\n"
                         "#   smallest_int = ceil(value)\n"
                         "# \n"
                         "# value: Any real number\n"
                         "# \n"
                         "# Example:\n"
                         "smallest_int = ceil(10.001)\n";

char ffilib_doc_floor[] = "Math (Basic)\n"
                          "floor(value)\n"
                          "# Returns the largest integer not greater than the value\n"
                          "# specified.\n"
                          "# \n"
                          "# Syntax:\n"
                          "#   largest_int = floor(value)\n"
                          "# \n"
                          "# value: Any real number\n"
                          "# \n"
                          "# Example:\n"
                          "largest_int = floor(10.999)\n";

char ffilib_doc_round[] = "Math (Basic)\n"
                          "round(value)\n"
                          "# Returns the integer nearest to the value specified.\n"
                          "# \n"
                          "# Syntax:\n"
                          "#   nearest_int = round(value)\n"
                          "# \n"
                          "# value: Any real number\n"
                          "# \n"
                          "# Example:\n"
                          "nearest_int = round(10.5)\n";

char ffilib_doc_timer[] = "Time\n"
                          "timer(wait_time)\n"
                          "# This function may only be used as a trigger in an\n"
                          "# action.\n"
                          "# \n"
                          "# The timer takes a single argument:  the number of\n"
                          "# milliseconds to wait until the timer goes off.  The\n"
                          "# timer will only trigger an action a single time until\n"
                          "# it finishes.  For a periodic timer, or a recurring\n"
                          "# timer with varying wait times, use 'ptimer()' or\n"
                          "# 'vtimer()'\n"
                          "# \n"
                          "# Syntax:\n"
                          "#   timer(wait_time)\n"
                          "# \n"
                          "# wait_time: The number of milliseconds to wait until\n"
                          "#   the action is triggered\n"
                          "# \n"
                          "# Example:\n"
                          "action timer(5000)\n"
                          "    message(\"5 seconds have gone by that you'll never get back\")\n"
                          "end\n";

char ffilib_doc_ptimer[] = "Time\n"
                           "ptimer(wait_time_interval)\n"
                           "# This function may only be used as a trigger in an\n"
                           "# action.\n"
                           "# \n"
                           "# The periodic timer takes a single argument:  the\n"
                           "# number of milliseconds to wait until the timer goes off.\n"
                           "# The timer goes off on periodically, with an interval of\n"
                           "# the number of milliseconds specified.  The timer will\n"
                           "# run until 'finish' is called for the unit.\n"
                           "# \n"
                           "# For a timer which will only fire a single time, use\n"
                           "# 'timer()'.  For a timer which will go off on variable\n"
                           "# intervals, and shut off if desired, use 'vtimer()'\n"
                           "# \n"
                           "# Syntax:\n"
                           "#   ptimer(wait_time_interval)\n"
                           "# \n"
                           "# wait_time_interval: The number of milliseconds to wait until\n"
                           "#   the action is triggered\n"
                           "# \n"
                           "# Example:\n"
                           "action ptimer(5000)\n"
                           "    message(\"This message is displayed every 5 seconds\")\n"
                           "end\n";

char ffilib_doc_vtimer[] = "Time\n"
                           "vtimer(variable_wait_time)\n"
                           "# This function may only be used as a trigger in an\n"
                           "# action.\n"
                           "# \n"
                           "# The variable wait time takes a single argument: the\n"
                           "# number of milliseconds to wait until the timer goes off\n"
                           "# Unlike 'ptimer()' or 'timer()', the wait time can be\n"
                           "# each time the action is triggered.  Changing the wait time\n"
                           "# to a value of '-1' will shut off the timer.\n"
                           "# \n"
                           "# For a timer which will only fire a single time, use\n"
                           "# 'timer()'.  For a timer which will go off at a set\n"
                           "# interval, use 'ptimer()'\n"
                           "# \n"
                           "# Syntax:\n"
                           "#   vtimer(variable_wait_time)\n"
                           "# \n"
                           "# variable_wait_time: The number of milliseconds to wait\n"
                           "#   until the action is triggered.  This value can be\n"
                           "#   changed whenever the action is triggered.  A value\n"
                           "#   of '-1' turns off the timer\n"
                           "# \n"
                           "# Example:\n"
                           "my_interval = 1000\n"
                           "\n"
                           "action vtimer(my_interval)\n"
                           "    # add one second to the timer interval\n"
                           "    my_interval = my_interval+1000\n"
                           "\n"
                           "    # if the interval reaches 10 seconds, turn off the timer\n"
                           "    if my_interval >= 10000\n"
                           "        my_interval = -1\n"
                           "    end\n"
                           "end\n";

char ffilib_doc_time[] = "Time\n"
                         "time()\n"
                         "# Returns the current time, in milliseconds, as a real\n"
                         "# number.\n"
                         "# \n"
                         "# Syntax:\n"
                         "#   real = time()\n"
                         "# \n"
                         "# Example:\n"
                         "time_in_ms = time()\n";

char ffilib_doc_delay[] = "Time\n"
                          "delay(wait_milliseconds)\n"
                          "# Delay the execution of the program by the specified\n"
                          "# number of milliseconds.\n"
                          "# \n"
                          "# Syntax:\n"
                          "#   delay(wait_milliseconds)\n"
                          "# \n"
                          "# wait_milliseconds: A real number specifying the number\n"
                          "#   of milliseconds to wait\n"
                          "# \n"
                          "# Example:\n"
                          "print(\"Start\")\n"
                          "delay(5000.0)\n"
                          "print(\"Done, 5 seconds later\")\n";

char ffilib_doc_graph[] = "Graphing\n"
                          "graph(title)\n"
                          "# Create a new graph with the specified title.  The graph\n"
                          "# will inherit the default configuration, such as color\n"
                          "# and plot mode.  The function will return a handle to\n"
                          "# the graph for use when more than one graph is needed.\n"
                          "# \n"
                          "# Syntax:\n"
                          "#   handle = graph(title)\n"
                          "# \n"
                          "# title: Any string you wish to use for the title\n"
                          "# \n"
                          "# Example:\n"
                          "set_def_plot_mode(\"lines\")\n"
                          "graph(\"My cool line plot\")\n"
                          "\n"
                          "plot(1, 10)\n";

char ffilib_doc_set_def_graph_color[] = "Graphing\n"
                                        "set_def_graph_color(color_string)\n"
                                        "# Set the default color to be used for newly created\n"
                                        "# graphs.  The color is specified using a hexidecimal\n"
                                        "# string to represent the colors red-green-blue.  The\n"
                                        "# color is applied to the background of the graph.\n"
                                        "# \n"
                                        "# Syntax:\n"
                                        "#   set_def_graph_color(color_string)\n"
                                        "# \n"
                                        "# color_string: A hexidecimal string specifying the\n"
                                        "#   colors red-green-blue, in that order\n"
                                        "# \n"
                                        "# Example:\n"
                                        "\n"
                                        "# Set the default color to bright red, with no green or\n"
                                        "# blue components\n"
                                        "set_def_graph_color(\"FF0000\")\n"
                                        "graph(\"A graph that will have a red background\")\n";

char ffilib_doc_set_def_domain[] = "Graphing\n"
                                   "set_def_domain(min_x, max_x)\n"
                                   "# Set the default domain that will be visible for newly\n"
                                   "# created graphs.  Setting a domain of 0, 0 will cause\n"
                                   "# the graph to be scaled so all points are visible on\n"
                                   "# the domain.\n"
                                   "# \n"
                                   "# Syntax:\n"
                                   "#   set_def_domain(min_x, max_x)\n"
                                   "# \n"
                                   "# min_x: A real number representing the minimum visible\n"
                                   "#   x coordinate\n"
                                   "# \n"
                                   "# max_x: A real number representing the maximum visible\n"
                                   "#   x coordinate\n"
                                   "# \n"
                                   "# Example:\n"
                                   "set_def_domain(-100.0, 100.0)\n"
                                   "graph(\"A graph with a domain of [-100.0, 100.0]\")\n";

char ffilib_doc_set_def_range[] = "Graphing\n"
                                  "set_def_range(min_y, max_y)\n"
                                  "# Set the default range that will be visible for newly\n"
                                  "# created graphs.  Setting a range of 0, 0 will cause\n"
                                  "# the graph to be scaled so all points are visible on\n"
                                  "# the range.\n"
                                  "# \n"
                                  "# Syntax:\n"
                                  "#   set_def_range(min_y, max_y)\n"
                                  "# \n"
                                  "# min_y: A real number representing the minimum visible\n"
                                  "#   y coordinate\n"
                                  "# \n"
                                  "# max_y: A real number representing the maximum visible\n"
                                  "#   y coordinate\n"
                                  "# \n"
                                  "# Example:\n"
                                  "set_def_range(-100.0, 100.0)\n"
                                  "graph(\"A graph with a range of [-100.0, 100.0]\")\n";

char ffilib_doc_set_graph_color[] = "Graphing\n"
                                    "set_graph_color(color_string)\n"
                                    "# Set the color to be used for as the background for the\n"
                                    "# current graph.  The color is specified using a\n"
                                    "# hexidecimal string to represent the colors\n"
                                    "# red-green-blue.  The color is applied to the background.\n"
                                    "# of the graph.\n"
                                    "# \n"
                                    "# Syntax:\n"
                                    "#   set_graph_color(color_string)\n"
                                    "# \n"
                                    "# color_string: A hexidecimal string specifying the\n"
                                    "#   colors red-green-blue, in that order\n"
                                    "# \n"
                                    "# Example:\n"
                                    "graph(\"A graph that needs a change in background\")\n"
                                    "\n"
                                    "# set the background color to bright green\n"
                                    "set_graph_color(\"00FF00\")\n";

char ffilib_doc_set_domain[] = "Graphing\n"
                               "set_domain(min_x, max_x)\n"
                               "# Set the default domain that will be visible for the\n"
                               "# current graph.  Setting a domain of 0, 0 will cause\n"
                               "# the graph to be scaled so all points are visible on\n"
                               "# the domain.\n"
                               "# \n"
                               "# Syntax:\n"
                               "#   set_domain(min_x, max_x)\n"
                               "# \n"
                               "# min_x: A real number representing the minimum visible\n"
                               "#   x coordinate\n"
                               "# \n"
                               "# max_x: A real number representing the maximum visible\n"
                               "#   x coordinate\n"
                               "# \n"
                               "# Example:\n"
                               "graph(\"A graph that needs a domain change\")\n"
                               "set_domain(-100.0, 100.0)\n";

char ffilib_doc_set_range[] = "Graphing\n"
                              "set_range(min_y, max_y)\n"
                              "# Set the default range that will be visible for the\n"
                              "# current graph.  Setting a range of 0, 0 will cause\n"
                              "# the graph to be scaled so all points are visible on\n"
                              "# the range.\n"
                              "# \n"
                              "# Syntax:\n"
                              "#   set_range(min_y, max_y)\n"
                              "# \n"
                              "# min_y: A real number representing the minimum visible\n"
                              "#   y coordinate\n"
                              "# \n"
                              "# max_y: A real number representing the maximum visible\n"
                              "#   y coordinate\n"
                              "# \n"
                              "# Example:\n"
                              "graph(\"A graph that needs a range change\")\n"
                              "set_range(-100.0, 100.0)\n";

char ffilib_doc_erase_plot[] = "Graphing\n"
                               "erase_plot()\n"
                               "# Erase all plotted points from the current graph.\n"
                               "# \n"
                               "# Syntax:\n"
                               "#   erase_plot()\n"
                               "# \n"
                               "# Example:\n"
                               "graph(\"A graph that will be erased\")\n"
                               "plot(1, 2)\n"
                               "plot(2, 3)\n"
                               "erase_plot()\n";

char ffilib_doc_hset_graph_color[] = "Graphing\n"
                                     "hset_graph_color(handle, color_string)\n"
                                     "# Similar to 'set_graph_color()', except this is the\n"
                                     "# handled version, which uses the specified graph to\n"
                                     "# operate on.\n"
                                     "# \n"
                                     "# Set the color to be used for as the background for the\n"
                                     "# specified graph.  The color is specified using a\n"
                                     "# hexidecimal string to represent the colors\n"
                                     "# red-green-blue.  The color is applied to the background.\n"
                                     "# of the graph.\n"
                                     "# \n"
                                     "# Syntax:\n"
                                     "#   set_graph_color(handle, color_string)\n"
                                     "# \n"
                                     "# handle: A graph handle returned by 'graph()'\n"
                                     "# \n"
                                     "# color_string: A hexidecimal string specifying the\n"
                                     "#   colors red-green-blue, in that order\n"
                                     "# \n"
                                     "# Example:\n"
                                     "g = graph(\"A graph that needs a change in background\")\n"
                                     "\n"
                                     "# set the background color to bright green\n"
                                     "hset_graph_color(g, \"00FF00\")\n";

char ffilib_doc_hset_domain[] = "Graphing\n"
                                "hset_domain(handle, min_x, max_x)\n"
                                "# Similar to 'set_domain()', except this is the\n"
                                "# handled version, which uses the specified graph to\n"
                                "# operate on.\n"
                                "# \n"
                                "# Set the default domain that will be visible for the\n"
                                "# specified graph.  Setting a domain of 0, 0 will cause\n"
                                "# the graph to be scaled so all points are visible on\n"
                                "# the domain.\n"
                                "# \n"
                                "# Syntax:\n"
                                "#   hset_domain(handle, min_x, max_x)\n"
                                "# \n"
                                "# handle: A graph handle returned by 'graph()'\n"
                                "# \n"
                                "# min_x: A real number representing the minimum visible\n"
                                "#   x coordinate\n"
                                "# \n"
                                "# max_x: A real number representing the maximum visible\n"
                                "#   x coordinate\n"
                                "# \n"
                                "# Example:\n"
                                "g = graph(\"A graph that needs a domain change\")\n"
                                "hset_domain(g, -100.0, 100.0)\n";

char ffilib_doc_hset_range[] = "Graphing\n"
                               "hset_range(handle, min_y, max_y)\n"
                               "# Similar to 'set_range()', except this is the\n"
                               "# handled version, which uses the specified graph to\n"
                               "# operate on.\n"
                               "# \n"
                               "# Set the default range that will be visible for the\n"
                               "# specified graph.  Setting a range of 0, 0 will cause\n"
                               "# the graph to be scaled so all points are visible on\n"
                               "# the range.\n"
                               "# \n"
                               "# Syntax:\n"
                               "#   hset_range(handle, min_y, max_y)\n"
                               "# \n"
                               "# handle: A graph handle returned by 'graph()'\n"
                               "# \n"
                               "# min_y: A real number representing the minimum visible\n"
                               "#   y coordinate\n"
                               "# \n"
                               "# max_y: A real number representing the maximum visible\n"
                               "#   y coordinate\n"
                               "# \n"
                               "# Example:\n"
                               "g = graph(\"A graph that needs a range change\")\n"
                               "hset_range(g, -100.0, 100.0)\n";

char ffilib_doc_herase_plot[] = "Graphing\n"
                                "herase_plot(handle)\n"
                                "# Similar to 'erase_plot()', except this is the\n"
                                "# handled version, which uses the specified graph to\n"
                                "# operate on.\n"
                                "# \n"
                                "# Erase all plotted points from the specified graph.\n"
                                "# \n"
                                "# Syntax:\n"
                                "#   herase_plot(handle)\n"
                                "# \n"
                                "# handle: A graph handle returned by 'graph()'\n"
                                "# \n"
                                "# Example:\n"
                                "g = graph(\"A graph that will be erased\")\n"
                                "hplot(g, 1, 2)\n"
                                "hplot(g, 2, 3)\n"
                                "herase_plot(g)\n";

char ffilib_doc_set_def_plot_weight[] = "Graphing\n"
                                        "set_def_plot_weight(weight_value)\n"
                                        "# Set the default thickness of the plotted points or\n"
                                        "# lines for newly created graphs.\n"
                                        "# \n"
                                        "# Syntax:\n"
                                        "#   set_def_plot_weight(weight_value)\n"
                                        "# \n"
                                        "# weight_value: A real value specifying the thickness of\n"
                                        "#   the plotted points.  By default this value is 1.0\n"
                                        "# \n"
                                        "# Example:\n"
                                        "set_def_plot_weight(5.0)\n"
                                        "graph(\"A graph that has a thick plot\")\n";

char ffilib_doc_set_def_plot_mode[] = "Graphing\n"
                                      "set_def_plot_mode(mode_string)\n"
                                      "# Set the default plot mode to be used for newly created\n"
                                      "# graphs.  By default, graphs will plot lines.\n"
                                      "# \n"
                                      "# Syntax:\n"
                                      "#   set_def_plot_mode(mode_string)\n"
                                      "# \n"
                                      "# mode_string: A string which specifies how to plot, this\n"
                                      "#   may be a value of \"lines\" to plot lines, or\n"
                                      "#   \"points\" to plot points.\n"
                                      "# \n"
                                      "# Example:\n"
                                      "set_def_plot_mode(\"points\")\n"
                                      "graph(\"A graph that will plot points\")\n";

char ffilib_doc_set_def_plot_color[] = "Graphing\n"
                                       "set_def_plot_color(color_string)\n"
                                       "# Set the default plot color to be used for newly\n"
                                       "# created graphs.  The color is specified using a\n"
                                       "# hexidecimal string to represent the colors\n"
                                       "# red-green-blue.  The color is applied to the\n"
                                       "# points plotted on the graph.\n"
                                       "# \n"
                                       "# Syntax:\n"
                                       "#   set_def_plot_color(color_string)\n"
                                       "# \n"
                                       "# color_string: A hexidecimal string specifying the\n"
                                       "#   colors red-green-blue, in that order\n"
                                       "# \n"
                                       "# Example:\n"
                                       "\n"
                                       "# Set the default plot color to bright blue, with no green or\n"
                                       "# blue components\n"
                                       "set_def_plot_color(\"0000FF\")\n"
                                       "graph(\"A graph that will plot in blue\")\n";

char ffilib_doc_set_plot_weight[] = "Graphing\n"
                                    "set_plot_weight(weight_value)\n"
                                    "# Set the thickness of the plotted points or lines for\n"
                                    "# the current graph.  This function does not change the\n"
                                    "# weight of previously plotted points on the graph\n"
                                    "# \n"
                                    "# Syntax:\n"
                                    "#   set_plot_weight(weight_value)\n"
                                    "# \n"
                                    "# weight_value: A real value specifying the thickness of\n"
                                    "#   the plotted points.  By default this value is 1.0\n"
                                    "# \n"
                                    "# Example:\n"
                                    "graph(\"A graph that needs a weight change\")\n"
                                    "set_plot_weight(5.0)\n";

char ffilib_doc_set_plot_mode[] = "Graphing\n"
                                  "set_plot_mode(mode_string)\n"
                                  "# Set the plot mode to be used for the current graph\n"
                                  "# This function does not change the mode of previously\n"
                                  "# plotted points on the graph.\n"
                                  "# \n"
                                  "# Syntax:\n"
                                  "#   set_plot_mode(mode_string)\n"
                                  "# \n"
                                  "# mode_string: A string which specifies how to plot, this\n"
                                  "#   may be a value of \"lines\" to plot lines, or\n"
                                  "#   \"points\" to plot points.\n"
                                  "# \n"
                                  "# Example:\n"
                                  "graph(\"A graph that will someday plot poitns\")\n"
                                  "set_plot_mode(\"points\")\n";

char ffilib_doc_set_plot_color[] = "Graphing\n"
                                   "set_plot_color(color_string)\n"
                                   "# Set the plot color to be used for the current graph\n"
                                   "# This function does not change the color of previously\n"
                                   "# plotted points on the graph.  The color is specified\n"
                                   "# using a hexidecimal string to represent the colors\n"
                                   "# red-green-blue.  The color is applied to the points\n"
                                   "# plotted on the graph.\n"
                                   "# \n"
                                   "# Syntax:\n"
                                   "#   set_plot_color(color_string)\n"
                                   "# \n"
                                   "# color_string: A hexidecimal string specifying the\n"
                                   "#   colors red-green-blue, in that order\n"
                                   "# \n"
                                   "# Example:\n"
                                   "\n"
                                   "graph(\"A graph that will someday plot in black\")\n"
                                   "set_plot_color(\"000000\")\n";

char ffilib_doc_hset_plot_weight[] = "Graphing\n"
                                     "hset_plot_weight(handle, weight_value)\n"
                                     "# Similar to 'set_plot_weight()', except this is the\n"
                                     "# handled version, which uses the specified graph to\n"
                                     "# operate on.\n"
                                     "# \n"
                                     "# Set the thickness of the plotted points or lines for\n"
                                     "# the specified graph.  This function does not change the\n"
                                     "# weight of previously plotted points on the graph\n"
                                     "# \n"
                                     "# Syntax:\n"
                                     "#   hset_plot_weight(handle, weight_value)\n"
                                     "# \n"
                                     "# handle: A graph handle returned by 'graph()'\n"
                                     "# \n"
                                     "# weight_value: A real value specifying the thickness of\n"
                                     "#   the plotted points.  By default this value is 1.0\n"
                                     "# \n"
                                     "# Example:\n"
                                     "g = graph(\"A graph that needs a weight change\")\n"
                                     "hset_plot_weight(g, 5.0)\n";

char ffilib_doc_hset_plot_mode[] = "Graphing\n"
                                   "hset_plot_mode(handle, mode_string)\n"
                                   "# Similar to 'set_plot_mode()', except this is the\n"
                                   "# handled version, which uses the specified graph to\n"
                                   "# operate on.\n"
                                   "# \n"
                                   "# Set the plot mode to be used for the specified graph\n"
                                   "# This function does not change the mode of previously\n"
                                   "# plotted points on the graph.\n"
                                   "# \n"
                                   "# Syntax:\n"
                                   "#  hset_plot_mode(handle, mode_string)\n"
                                   "# \n"
                                   "# handle: A graph handle returned by 'graph()'\n"
                                   "# \n"
                                   "# mode_string: A string which specifies how to plot, this\n"
                                   "#   may be a value of \"lines\" to plot lines, or\n"
                                   "#   \"points\" to plot points.\n"
                                   "# \n"
                                   "# Example:\n"
                                   "g = graph(\"A graph that will someday plot poitns\")\n"
                                   "hset_plot_mode(g, \"points\")\n";

char ffilib_doc_hset_plot_color[] = "Graphing\n"
                                    "hset_plot_color(handle, color_string)\n"
                                    "# Similar to 'set_plot_color()', except this is the\n"
                                    "# handled version, which uses the specified graph to\n"
                                    "# operate on.\n"
                                    "# \n"
                                    "# Set the plot color to be used for the specified graph\n"
                                    "# This function does not change the color of previously\n"
                                    "# plotted points on the graph.  The color is specified\n"
                                    "# using a hexidecimal string to represent the colors\n"
                                    "# red-green-blue.  The color is applied to the points\n"
                                    "# plotted on the graph.\n"
                                    "# \n"
                                    "# Syntax:\n"
                                    "#   hset_plot_color(handle, color_string)\n"
                                    "# \n"
                                    "# handle: A graph handle returned by 'graph()'\n"
                                    "# \n"
                                    "# color_string: A hexidecimal string specifying the\n"
                                    "#   colors red-green-blue, in that order\n"
                                    "# \n"
                                    "# Example:\n"
                                    "\n"
                                    "g = graph(\"A graph that will someday plot in black\")\n"
                                    "hset_plot_color(g, \"000000\")\n";

char ffilib_doc_plot[] = "Graphing\n"
                         "plot(x, y)\n"
                         "# Plot a point on the current graph at the specified x\n"
                         "# and y coordinate.\n"
                         "# \n"
                         "# Syntax:\n"
                         "#   plot(x, y)\n"
                         "# \n"
                         "# x: A real number specifying the x coordinate\n"
                         "# \n"
                         "# y: A real number specifying the y coordinate\n"
                         "# \n"
                         "# Example:\n"
                         "graph(\"A graph to be plotted on\")\n"
                         "plot(1.0, 100.0)\n";

char ffilib_doc_hplot[] = "Graphing\n"
                          "hplot(handle, x, y)\n"
                          "# Similar to 'plot()', except this is the handled \n"
                          "# version, which uses the specified graph to operate\n"
                          "# on.\n"
                          "# \n"
                          "# Plot a point on the specified graph at the specified x\n"
                          "# and y coordinate.\n"
                          "# \n"
                          "# Syntax:\n"
                          "#   hplot(handle, x, y)\n"
                          "# \n"
                          "# handle: A graph handle returned by 'graph()'\n"
                          "# \n"
                          "# x: A real number specifying the x coordinate\n"
                          "# \n"
                          "# y: A real number specifying the y coordinate\n"
                          "# \n"
                          "# Example:\n"
                          "g = graph(\"A graph to be plotted on\")\n"
                          "hplot(g, 1.0, 100.0)\n";

